from complaint_extractor_local import ComplaintProcessorLocal
import json
import time
import threading
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List, Dict, Any
import os
from collections import defaultdict

# 测试数据集
TEST_COMPLAINTS = [
    # 停电类
    """客户无投诉意愿。客户反映，该地点又停电。[客户表述]具体停电时间：[两三天前故障，现在又没电了]。
    影响正常用电，请相关部门尽快核实处理。""",
    
    # 房屋维修类
    """王女士反映：家住午山村1号楼503户，房子于2017年回迁交付，2021年冬房屋漏水，
    多次反馈未处理。要求部门协调尽快维修房屋。请责任部门落实处理并答复。""",
    
    # 占道经营类
    """孙先生反映：长春花园小区，在小区东北门外经常有收废品人员，使用三轮车占据人行道，
    要求部门管理禁止占道收废品，请相关部门落实处理并答复。""",
    
    # 噪音扰民类
    """李先生投诉：幸福小区5号楼，楼上住户每天凌晨3点开始装修，噪音严重影响休息。
    多次沟通无果，要求相关部门进行处理。""",
    
    # 物业服务类
    """张女士反映：和平小区物业服务态度恶劣，电梯维修问题反映多次未解决，
    老人爬楼非常困难。要求物业公司重视并尽快解决。""",
    
    # 环境卫生类
    """赵先生反映：文明路与和平路交叉口，垃圾桶长期未清理，散发异味，
    影响周边居民生活。要求环卫部门及时清理。""",
    
    # 车辆管理类
    """陈女士反映：幸福小区地下停车场，有多辆僵尸车长期占用车位，
    物业不作为。希望相关部门核实处理。""",
    
    # 安全隐患类
    """刘先生反映：阳光小区3号楼一楼，有人私自改装房屋结构，
    疑似影响建筑安全。要求相关部门检查处理。""",
    
    # 绿化养护类
    """周女士反映：和谐路绿化带杂草丛生，蚊虫滋生，
    影响市容市貌和居民生活。要求园林部门及时处理。""",
    
    # 邻里纠纷类
    """马先生反映：欢乐小区8号楼，邻居在公共走廊堆放杂物，
    多次协商未果，存在安全隐患。请相关部门协调处理。"""
]

class ComplaintProcessor:
    def __init__(self, output_dir: str = "processed_complaints"):
        """初始化处理器
        Args:
            output_dir: 结果保存目录
        """
        self.processor = ComplaintProcessorLocal()
        self.output_dir = output_dir
        os.makedirs(output_dir, exist_ok=True)
        self.execution_times = defaultdict(list)  # 用于记录每个投诉类型的执行时间
        self.lock = threading.Lock()  # 用于线程安全的数据记录

    def process_single_complaint(self, complaint: str, complaint_id: int) -> Dict[str, Any]:
        """处理单个投诉
        Args:
            complaint: 投诉内容
            complaint_id: 投诉ID
        Returns:
            处理结果和执行时间
        """
        start_time = time.time()
        try:
            # 处理投诉
            result = self.processor.process_complaint(complaint)
            
            # 保存结果
            if result:
                self.processor.save_result(result, self.output_dir, f"complaint_{complaint_id}")
            
            end_time = time.time()
            execution_time = end_time - start_time
            
            # 线程安全地记录执行时间
            with self.lock:
                self.execution_times[complaint_id % len(TEST_COMPLAINTS)].append(execution_time)
            
            return {
                "complaint_id": complaint_id,
                "execution_time": execution_time,
                "result": result
            }
            
        except Exception as e:
            print(f"处理投诉 {complaint_id} 时出错: {e}")
            return {
                "complaint_id": complaint_id,
                "execution_time": time.time() - start_time,
                "result": None,
                "error": str(e)
            }

    def process_complaints_parallel(self, target_thread_count: int = 50, max_workers: int = 50) -> List[Dict[str, Any]]:
        """并行处理多个投诉
        Args:
            target_thread_count: 目标线程数量
            max_workers: 最大线程数
        Returns:
            处理结果列表
        """
        results = []
        
        # 生成足够数量的投诉数据
        complaints = []
        for i in range(target_thread_count):
            complaint_index = i % len(TEST_COMPLAINTS)
            complaints.append(TEST_COMPLAINTS[complaint_index])
        
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            # 提交所有任务
            future_to_complaint = {
                executor.submit(self.process_single_complaint, complaint, i): i 
                for i, complaint in enumerate(complaints, 1)
            }
            
            # 获取结果
            completed_count = 0
            for future in as_completed(future_to_complaint):
                complaint_id = future_to_complaint[future]
                completed_count += 1
                try:
                    result = future.result()
                    results.append(result)
                    print(f"\n完成进度: {completed_count}/{len(complaints)} ({completed_count/len(complaints)*100:.1f}%)")
                    print(f"投诉 {complaint_id} 处理完成:")
                    print(f"执行时间: {result['execution_time']:.2f} 秒")
                    if result['result']:
                        print("处理结果:")
                        print(json.dumps(result['result'], ensure_ascii=False, indent=2))
                    else:
                        print(f"处理失败: {result.get('error', '未知错误')}")
                except Exception as e:
                    print(f"获取投诉 {complaint_id} 结果时出错: {e}")
        
        return results

    def analyze_execution_times(self):
        """分析执行时间统计"""
        print("\n执行时间统计分析:")
        for complaint_index, times in self.execution_times.items():
            if times:
                avg_time = sum(times) / len(times)
                min_time = min(times)
                max_time = max(times)
                print(f"\n投诉类型 {complaint_index + 1}:")
                print(f"平均执行时间: {avg_time:.2f} 秒")
                print(f"最短执行时间: {min_time:.2f} 秒")
                print(f"最长执行时间: {max_time:.2f} 秒")
                print(f"执行次数: {len(times)}")

def main():
    # 初始化处理器
    processor = ComplaintProcessor()
    
    # 设置目标线程数和最大线程数
    target_thread_count = 30
    max_workers = 30
    
    print(f"开始处理 {target_thread_count} 个任务，使用最多 {max_workers} 个线程...")
    start_time = time.time()
    
    # 并行处理投诉
    results = processor.process_complaints_parallel(target_thread_count, max_workers)
    
    # 统计结果
    end_time = time.time()
    total_time = end_time - start_time
    successful_count = sum(1 for r in results if r['result'] is not None)
    
    print("\n处理统计:")
    print(f"总任务数: {len(results)}")
    print(f"成功处理: {successful_count}")
    print(f"失败数量: {len(results) - successful_count}")
    print(f"总执行时间: {total_time:.2f} 秒")
    print(f"平均执行时间: {total_time/len(results):.2f} 秒")
    
    # 输出每个投诉的执行时间（按时间排序）
    print("\n各任务执行时间:")
    for result in sorted(results, key=lambda x: x['execution_time']):
        print(f"任务 {result['complaint_id']}: {result['execution_time']:.2f} 秒")
    
    # 分析执行时间统计
    processor.analyze_execution_times()

if __name__ == "__main__":
    main() 